/*
 * 🎤 AIOT智能学习桌 - 智能语音交互系统
 *
 * 核心功能：
 * ✅ 智能语音识别 (支持唤醒词"小助手")
 * ✅ AI对话系统 (集成OpenAI GPT API)
 * ✅ 语音合成播报 (TTS文本转语音)
 * ✅ 微信小程序语音通信
 * ✅ 多轮对话上下文管理
 * ✅ 智能学习建议生成
 * ✅ 个性化语音助手
 *
 * 硬件配置：
 * - 麦克风模块: MAX4466 (J2 PMOD接口)
 * - 音频放大器: PAM8403 (J10 PMOD接口)
 * - 喇叭: 8Ω 2W
 * - WiFi模块: ESP8266 (UART5通信)
 *
 * 作者: AIOT智能学习桌项目组
 * 版本: v2.0 AI增强版
 */

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <math.h>
#include <time.h>
#include <ctype.h>
#include "voice_interaction.h"
#include "ai_api_client.h"
#include "audio_processing.h"
#include "wechat_integration.h"
#include "user_context.h"

// ========== 硬件配置 ==========
#define MIC_INPUT_PIN 85    // 麦克风输入 (J2 PMOD GPIO85)
#define AUDIO_OUTPUT_PIN 25 // 音频输出 (J10 PMOD GPIO25)
#define VOICE_UART 5        // 语音模块UART
#define WIFI_UART 5         // WiFi模块UART

// ========== 语音识别参数 ==========
#define WAKE_WORD "小助手"
#define SAMPLE_RATE 16000        // 采样率
#define FRAME_SIZE 1024          // 帧大小
#define VOICE_THRESHOLD 300      // 语音检测阈值
#define SILENCE_TIMEOUT 2000     // 静音超时(ms)
#define MAX_RECORDING_TIME 10000 // 最大录音时间(ms)

// ========== AI API配置 ==========
#define AI_API_URL "https://api.openai.com/v1/chat/completions"
#define AI_API_KEY "your-openai-api-key" // 需要替换为实际密钥
#define TTS_API_URL "https://api.openai.com/v1/audio/speech"
#define MAX_CONVERSATION_HISTORY 10 // 最大对话历史条数
#define MAX_MESSAGE_LENGTH 512      // 最大消息长度
#define MAX_RESPONSE_LENGTH 1024    // 最大响应长度

// ========== 数据结构定义 ==========

// 语音识别结果
typedef struct
{
    char text[MAX_MESSAGE_LENGTH]; // 识别文本
    float confidence;              // 置信度
    uint32_t timestamp;            // 时间戳
    bool is_wake_word_detected;    // 是否检测到唤醒词
    bool is_valid_command;         // 是否有效命令
} VoiceRecognitionResult;

// AI对话消息
typedef struct
{
    char role[16];                    // 角色 (user/assistant/system)
    char content[MAX_MESSAGE_LENGTH]; // 消息内容
    uint32_t timestamp;               // 时间戳
} ConversationMessage;

// 对话上下文
typedef struct
{
    ConversationMessage history[MAX_CONVERSATION_HISTORY]; // 对话历史
    int message_count;                                     // 消息数量
    int current_index;                                     // 当前索引
    char user_name[64];                                    // 用户名
    char user_preferences[256];                            // 用户偏好
    uint32_t session_start_time;                           // 会话开始时间
    int total_interactions;                                // 总交互次数
} ConversationContext;

// 语音合成配置
typedef struct
{
    char voice_model[32]; // 语音模型
    float speed;          // 语速
    float pitch;          // 音调
    float volume;         // 音量
    char language[8];     // 语言代码
} TTSConfig;

// 智能助手状态
typedef struct
{
    bool is_listening;              // 是否在监听
    bool is_processing;             // 是否在处理
    bool is_speaking;               // 是否在播报
    bool wake_word_detected;        // 唤醒词检测状态
    uint32_t last_interaction_time; // 最后交互时间
    int error_count;                // 错误计数
    bool ai_enabled;                // AI功能是否启用
    bool wechat_connected;          // 微信连接状态
} AssistantState;

// 音频缓冲区
typedef struct
{
    int16_t buffer[FRAME_SIZE];    // 音频缓冲区
    int buffer_index;              // 缓冲区索引
    bool is_recording;             // 是否在录音
    uint32_t recording_start_time; // 录音开始时间
    float energy_level;            // 能量级别
} AudioBuffer;

// ========== 全局变量 ==========
static ConversationContext g_conversation_context;
static AssistantState g_assistant_state;
static TTSConfig g_tts_config;
static AudioBuffer g_audio_buffer;
static VoiceRecognitionResult g_last_recognition;

// 预定义AI系统提示词
static const char *SYSTEM_PROMPT =
    "你是一个智能学习桌的AI助手，名字叫'小助手'。"
    "你的主要任务是帮助用户：1)提供学习建议 2)监督坐姿健康 3)答疑解惑 4)时间管理。"
    "请用简洁、友好、鼓励的语言回复，每次回复控制在50字以内。"
    "你可以获取用户的坐姿数据、学习时间等信息来提供个性化建议。";

// ========== 核心功能实现 ==========

/**
 * @brief 初始化语音交互系统
 * @return int 初始化结果 (0: 成功, -1: 失败)
 */
int voice_interaction_init(void)
{
    printf("🎤 初始化智能语音交互系统...\n");

    // 硬件初始化
    if (audio_hardware_init() != 0)
    {
        printf("❌ 音频硬件初始化失败\n");
        return -1;
    }

    if (wifi_communication_init() != 0)
    {
        printf("❌ WiFi通信初始化失败\n");
        return -1;
    }

    // 语音处理引擎初始化
    if (voice_recognition_engine_init() != 0)
    {
        printf("❌ 语音识别引擎初始化失败\n");
        return -1;
    }

    if (tts_engine_init() != 0)
    {
        printf("❌ 语音合成引擎初始化失败\n");
        return -1;
    }

    // 系统状态初始化
    memset(&g_conversation_context, 0, sizeof(g_conversation_context));
    memset(&g_assistant_state, 0, sizeof(g_assistant_state));
    memset(&g_audio_buffer, 0, sizeof(g_audio_buffer));
    memset(&g_last_recognition, 0, sizeof(g_last_recognition));

    // 初始化TTS配置
    strcpy(g_tts_config.voice_model, "zh-CN-YunxiNeural");
    g_tts_config.speed = 1.0f;
    g_tts_config.pitch = 1.0f;
    g_tts_config.volume = 0.8f;
    strcpy(g_tts_config.language, "zh-CN");

    // 初始化助手状态
    g_assistant_state.ai_enabled = true;
    g_assistant_state.is_listening = true;
    g_assistant_state.wake_word_detected = false;

    // 加载用户上下文
    load_user_context(&g_conversation_context);

    // 添加系统消息
    add_system_message_to_context();

    // 系统自检
    if (voice_system_self_test() != 0)
    {
        printf("❌ 语音系统自检失败\n");
        return -1;
    }

    // 播放启动欢迎语
    speak_welcome_message();

    printf("✅ 智能语音交互系统初始化完成\n");
    return 0;
}

/**
 * @brief 语音交互主循环
 * @return int 执行结果
 */
int voice_interaction_loop(void)
{
    static uint32_t last_audio_check = 0;
    uint32_t current_time = get_system_time_ms();

    // 音频输入检测 (每50ms检查一次)
    if (current_time - last_audio_check >= 50)
    {
        process_audio_input();
        last_audio_check = current_time;
    }

    // 处理语音识别结果
    if (g_assistant_state.is_processing)
    {
        process_voice_recognition_result();
    }

    // 处理微信小程序语音消息
    handle_wechat_voice_messages();

    // 检查超时和错误恢复
    check_timeout_and_recovery(current_time);

    // 定期保存对话上下文
    save_conversation_context_periodically(current_time);

    return 0;
}

/**
 * @brief 处理音频输入
 */
void process_audio_input(void)
{
    // 读取麦克风数据
    int16_t audio_sample = read_audio_sample(MIC_INPUT_PIN);

    // 计算音频能量
    float energy = calculate_audio_energy(audio_sample);
    g_audio_buffer.energy_level = energy;

    // 检测语音活动
    if (energy > VOICE_THRESHOLD && !g_audio_buffer.is_recording)
    {
        start_voice_recording();
    }
    else if (energy <= VOICE_THRESHOLD && g_audio_buffer.is_recording)
    {
        // 检测静音，判断是否结束录音
        static uint32_t silence_start = 0;
        if (silence_start == 0)
        {
            silence_start = get_system_time_ms();
        }
        else if (get_system_time_ms() - silence_start > SILENCE_TIMEOUT)
        {
            stop_voice_recording();
            silence_start = 0;
        }
    }
    else if (g_audio_buffer.is_recording)
    {
        // 继续录音
        record_audio_sample(audio_sample);

        // 检查录音时间限制
        if (get_system_time_ms() - g_audio_buffer.recording_start_time > MAX_RECORDING_TIME)
        {
            stop_voice_recording();
        }
    }
}

/**
 * @brief 开始语音录音
 */
void start_voice_recording(void)
{
    if (g_assistant_state.is_speaking)
    {
        return; // 正在播报时不录音
    }

    printf("🎙️ 开始录音...\n");

    g_audio_buffer.is_recording = true;
    g_audio_buffer.recording_start_time = get_system_time_ms();
    g_audio_buffer.buffer_index = 0;

    // 清空缓冲区
    memset(g_audio_buffer.buffer, 0, sizeof(g_audio_buffer.buffer));

    // 更新状态
    g_assistant_state.is_listening = true;

    // 可选：播放录音提示音
    // play_recording_beep();
}

/**
 * @brief 停止语音录音
 */
void stop_voice_recording(void)
{
    if (!g_audio_buffer.is_recording)
        return;

    printf("🎙️ 停止录音，开始识别...\n");

    g_audio_buffer.is_recording = false;
    g_assistant_state.is_processing = true;

    // 启动语音识别
    start_voice_recognition();

    // 可选：播放处理提示音
    // play_processing_beep();
}

/**
 * @brief 记录音频样本
 * @param sample 音频样本
 */
void record_audio_sample(int16_t sample)
{
    if (g_audio_buffer.buffer_index < FRAME_SIZE)
    {
        g_audio_buffer.buffer[g_audio_buffer.buffer_index++] = sample;
    }
}

/**
 * @brief 计算音频能量
 * @param sample 音频样本
 * @return float 能量值
 */
float calculate_audio_energy(int16_t sample)
{
    static float energy_sum = 0;
    static int sample_count = 0;

    energy_sum += (float)(sample * sample);
    sample_count++;

    if (sample_count >= 100)
    { // 每100个样本计算一次平均能量
        float avg_energy = sqrt(energy_sum / sample_count);
        energy_sum = 0;
        sample_count = 0;
        return avg_energy;
    }

    return g_audio_buffer.energy_level; // 返回上次计算的能量值
}

/**
 * @brief 启动语音识别
 */
void start_voice_recognition(void)
{
    // 将音频数据发送给语音识别服务
    if (send_audio_to_recognition_service() == 0)
    {
        printf("🔍 语音识别处理中...\n");
    }
    else
    {
        printf("❌ 语音识别启动失败\n");
        g_assistant_state.is_processing = false;
        g_assistant_state.error_count++;
    }
}

/**
 * @brief 发送音频到识别服务
 * @return int 发送结果
 */
int send_audio_to_recognition_service(void)
{
    // 这里应该调用真实的语音识别API
    // 现在使用简化的模拟识别

    // 模拟识别延时
    delay_ms(1000);

    // 模拟识别结果
    simulate_voice_recognition_result();

    return 0;
}

/**
 * @brief 模拟语音识别结果
 */
void simulate_voice_recognition_result(void)
{
    // 简单的模拟识别结果，实际项目中应该调用真实的ASR API
    static int test_counter = 0;
    test_counter++;

    const char *test_phrases[] = {
        "小助手，现在几点了？",
        "小助手，我的坐姿怎么样？",
        "小助手，今天学习了多长时间？",
        "小助手，给我一些学习建议",
        "小助手，帮我设置休息提醒",
        "小助手，我感觉有点累",
        "小助手，这道题怎么做？",
        "小助手，明天的计划是什么？"};

    int phrase_index = test_counter % 8;
    strcpy(g_last_recognition.text, test_phrases[phrase_index]);
    g_last_recognition.confidence = 0.85f + (rand() % 15) / 100.0f;
    g_last_recognition.timestamp = get_system_time_ms();
    g_last_recognition.is_wake_word_detected = true;
    g_last_recognition.is_valid_command = true;

    printf("🎯 模拟识别结果: %s (置信度: %.2f)\n",
           g_last_recognition.text, g_last_recognition.confidence);
}

/**
 * @brief 处理语音识别结果
 */
void process_voice_recognition_result(void)
{
    if (!g_assistant_state.is_processing)
        return;

    // 检查识别置信度
    if (g_last_recognition.confidence < 0.6f)
    {
        handle_low_confidence_recognition();
        return;
    }

    // 检查是否包含唤醒词
    if (!g_last_recognition.is_wake_word_detected)
    {
        if (contains_wake_word(g_last_recognition.text))
        {
            g_last_recognition.is_wake_word_detected = true;
        }
        else
        {
            // 未检测到唤醒词，继续监听
            g_assistant_state.is_processing = false;
            return;
        }
    }

    // 处理有效的语音命令
    if (g_last_recognition.is_valid_command)
    {
        process_voice_command(g_last_recognition.text);
    }

    g_assistant_state.is_processing = false;
}

/**
 * @brief 检查是否包含唤醒词
 * @param text 识别文本
 * @return bool 是否包含唤醒词
 */
bool contains_wake_word(const char *text)
{
    return strstr(text, WAKE_WORD) != NULL;
}

/**
 * @brief 处理低置信度识别
 */
void handle_low_confidence_recognition(void)
{
    printf("⚠️ 识别置信度过低: %.2f\n", g_last_recognition.confidence);

    g_assistant_state.error_count++;
    g_assistant_state.is_processing = false;

    // 如果连续识别失败次数过多，播放提示
    if (g_assistant_state.error_count >= 3)
    {
        speak_message("抱歉，我没有听清楚，请再说一遍。");
        g_assistant_state.error_count = 0;
    }
}

/**
 * @brief 处理语音命令
 * @param command 语音命令
 */
void process_voice_command(const char *command)
{
    printf("🎤 处理语音命令: %s\n", command);

    // 添加用户消息到对话上下文
    add_user_message_to_context(command);

    // 重置错误计数
    g_assistant_state.error_count = 0;

    // 更新交互时间
    g_assistant_state.last_interaction_time = get_system_time_ms();
    g_conversation_context.total_interactions++;

    // 分析命令类型并生成响应
    char response[MAX_RESPONSE_LENGTH];
    if (generate_ai_response(command, response) == 0)
    {
        // 添加助手响应到上下文
        add_assistant_message_to_context(response);

        // 播报响应
        speak_message(response);

        // 发送交互记录到微信小程序
        send_voice_interaction_to_wechat(command, response);

        printf("🤖 AI回复: %s\n", response);
    }
    else
    {
        // AI API调用失败，使用预设回复
        char fallback_response[256];
        generate_fallback_response(command, fallback_response);
        speak_message(fallback_response);

        printf("🔄 降级回复: %s\n", fallback_response);
    }
}

/**
 * @brief 生成AI响应
 * @param user_input 用户输入
 * @param response 响应输出缓冲区
 * @return int 生成结果 (0: 成功, -1: 失败)
 */
int generate_ai_response(const char *user_input, char *response)
{
    if (!g_assistant_state.ai_enabled || !g_assistant_state.wechat_connected)
    {
        return -1; // AI功能未启用或网络未连接
    }

    // 构建AI API请求
    char json_request[2048];
    if (build_ai_api_request(user_input, json_request, sizeof(json_request)) != 0)
    {
        return -1;
    }

    // 发送HTTP请求到AI API
    char api_response[2048];
    if (send_http_request(AI_API_URL, json_request, api_response, sizeof(api_response)) != 0)
    {
        return -1;
    }

    // 解析API响应
    if (parse_ai_api_response(api_response, response, MAX_RESPONSE_LENGTH) != 0)
    {
        return -1;
    }

    return 0;
}

/**
 * @brief 构建AI API请求
 * @param user_input 用户输入
 * @param json_request 请求JSON输出
 * @param buffer_size 缓冲区大小
 * @return int 构建结果
 */
int build_ai_api_request(const char *user_input, char *json_request, size_t buffer_size)
{
    // 构建包含对话历史的请求
    char messages_json[1536] = "";

    // 添加系统消息
    strcat(messages_json, "{\"role\":\"system\",\"content\":\"");
    strcat(messages_json, SYSTEM_PROMPT);
    strcat(messages_json, "\"},");

    // 添加最近几轮对话历史
    int history_count = 0;
    for (int i = 0; i < g_conversation_context.message_count && history_count < 6; i++)
    {
        int index = (g_conversation_context.current_index - i - 1 + MAX_CONVERSATION_HISTORY) % MAX_CONVERSATION_HISTORY;

        if (strlen(g_conversation_context.history[index].content) > 0)
        {
            strcat(messages_json, "{\"role\":\"");
            strcat(messages_json, g_conversation_context.history[index].role);
            strcat(messages_json, "\",\"content\":\"");
            strcat(messages_json, g_conversation_context.history[index].content);
            strcat(messages_json, "\"},");
            history_count++;
        }
    }

    // 添加当前用户输入
    strcat(messages_json, "{\"role\":\"user\",\"content\":\"");
    strcat(messages_json, user_input);
    strcat(messages_json, "\"}");

    // 构建完整的JSON请求
    snprintf(json_request, buffer_size,
             "{"
             "\"model\":\"gpt-3.5-turbo\","
             "\"messages\":[%s],"
             "\"max_tokens\":100,"
             "\"temperature\":0.7,"
             "\"top_p\":1,"
             "\"frequency_penalty\":0,"
             "\"presence_penalty\":0"
             "}",
             messages_json);

    return 0;
}

/**
 * @brief 解析AI API响应
 * @param api_response API原始响应
 * @param parsed_response 解析后的响应
 * @param buffer_size 缓冲区大小
 * @return int 解析结果
 */
int parse_ai_api_response(const char *api_response, char *parsed_response, size_t buffer_size)
{
    // 简化的JSON解析，实际项目中应该使用专业的JSON解析库
    const char *content_start = strstr(api_response, "\"content\":\"");
    if (!content_start)
    {
        return -1;
    }

    content_start += 11; // 跳过 "content":"
    const char *content_end = strstr(content_start, "\",");
    if (!content_end)
    {
        content_end = strstr(content_start, "\"}");
        if (!content_end)
        {
            return -1;
        }
    }

    size_t content_length = content_end - content_start;
    if (content_length >= buffer_size)
    {
        content_length = buffer_size - 1;
    }

    strncpy(parsed_response, content_start, content_length);
    parsed_response[content_length] = '\0';

    // 清理转义字符
    clean_json_escapes(parsed_response);

    return 0;
}

/**
 * @brief 清理JSON转义字符
 * @param text 文本
 */
void clean_json_escapes(char *text)
{
    char *src = text;
    char *dst = text;

    while (*src)
    {
        if (*src == '\\' && *(src + 1))
        {
            switch (*(src + 1))
            {
            case 'n':
                *dst++ = '\n';
                src += 2;
                break;
            case 't':
                *dst++ = '\t';
                src += 2;
                break;
            case 'r':
                *dst++ = '\r';
                src += 2;
                break;
            case '\\':
                *dst++ = '\\';
                src += 2;
                break;
            case '"':
                *dst++ = '"';
                src += 2;
                break;
            default:
                *dst++ = *src++;
                break;
            }
        }
        else
        {
            *dst++ = *src++;
        }
    }
    *dst = '\0';
}

/**
 * @brief 生成降级回复
 * @param command 命令
 * @param response 回复
 */
void generate_fallback_response(const char *command, char *response)
{
    // 基于关键词的简单回复生成
    if (strstr(command, "时间") || strstr(command, "几点"))
    {
        sprintf(response, "现在时间是%s，您已经学习了一段时间，记得适当休息。", get_current_time_string());
    }
    else if (strstr(command, "坐姿"))
    {
        strcpy(response, "请保持良好的坐姿，背部挺直，与屏幕保持合适距离。");
    }
    else if (strstr(command, "学习") && strstr(command, "时间"))
    {
        strcpy(response, "您今天的学习时间很充足，继续保持这种学习状态。");
    }
    else if (strstr(command, "建议") || strstr(command, "帮助"))
    {
        strcpy(response, "建议您定时休息，保持良好坐姿，合理安排学习时间。");
    }
    else if (strstr(command, "累") || strstr(command, "疲劳"))
    {
        strcpy(response, "感觉累了就休息一下，站起来活动活动，眺望远方放松眼睛。");
    }
    else if (strstr(command, "休息"))
    {
        strcpy(response, "很好，适当的休息有助于提高学习效率，建议您起身活动5-10分钟。");
    }
    else
    {
        strcpy(response, "我理解您的问题，让我们一起努力创造更好的学习环境。");
    }
}

/**
 * @brief 播报语音消息
 * @param message 消息内容
 */
void speak_message(const char *message)
{
    if (!message || strlen(message) == 0)
        return;

    printf("🔊 语音播报: %s\n", message);

    g_assistant_state.is_speaking = true;

    // 调用TTS API生成语音
    if (generate_speech_audio(message) == 0)
    {
        // 播放生成的语音
        play_speech_audio();
    }
    else
    {
        // TTS失败，使用蜂鸣器模拟语音
        simulate_speech_with_beeper(message);
    }

    g_assistant_state.is_speaking = false;
}

/**
 * @brief 生成语音音频
 * @param text 文本
 * @return int 生成结果
 */
int generate_speech_audio(const char *text)
{
    // 构建TTS API请求
    char tts_request[1024];
    snprintf(tts_request, sizeof(tts_request),
             "{"
             "\"model\":\"tts-1\","
             "\"input\":\"%s\","
             "\"voice\":\"%s\","
             "\"speed\":%.1f"
             "}",
             text, g_tts_config.voice_model, g_tts_config.speed);

    // 发送TTS请求
    char audio_data[4096];
    if (send_http_request(TTS_API_URL, tts_request, audio_data, sizeof(audio_data)) == 0)
    {
        // 保存音频数据到缓冲区或文件
        save_audio_data(audio_data);
        return 0;
    }

    return -1;
}

/**
 * @brief 播放语音音频
 */
void play_speech_audio(void)
{
    // 从缓冲区播放音频数据
    // 这里应该实现实际的音频播放逻辑

    // 模拟播放延时
    delay_ms(strlen(g_last_recognition.text) * 100); // 根据文本长度估算播放时间
}

/**
 * @brief 用蜂鸣器模拟语音
 * @param text 文本
 */
void simulate_speech_with_beeper(const char *text)
{
    // 用不同音调的蜂鸣器声音模拟语音节奏
    int text_length = strlen(text);

    for (int i = 0; i < text_length && i < 10; i++)
    {
        int frequency = 800 + (text[i] % 8) * 50; // 根据字符生成不同频率
        play_beep(frequency, 100);
        delay_ms(50);
    }
}

/**
 * @brief 添加用户消息到上下文
 * @param message 用户消息
 */
void add_user_message_to_context(const char *message)
{
    add_message_to_context("user", message);
}

/**
 * @brief 添加助手消息到上下文
 * @param message 助手消息
 */
void add_assistant_message_to_context(const char *message)
{
    add_message_to_context("assistant", message);
}

/**
 * @brief 添加系统消息到上下文
 */
void add_system_message_to_context(void)
{
    add_message_to_context("system", SYSTEM_PROMPT);
}

/**
 * @brief 添加消息到对话上下文
 * @param role 角色
 * @param content 内容
 */
void add_message_to_context(const char *role, const char *content)
{
    ConversationMessage *msg = &g_conversation_context.history[g_conversation_context.current_index];

    strcpy(msg->role, role);
    strncpy(msg->content, content, MAX_MESSAGE_LENGTH - 1);
    msg->content[MAX_MESSAGE_LENGTH - 1] = '\0';
    msg->timestamp = get_system_time_ms();

    g_conversation_context.current_index =
        (g_conversation_context.current_index + 1) % MAX_CONVERSATION_HISTORY;

    if (g_conversation_context.message_count < MAX_CONVERSATION_HISTORY)
    {
        g_conversation_context.message_count++;
    }
}

/**
 * @brief 处理微信小程序语音消息
 */
void handle_wechat_voice_messages(void)
{
    if (!g_assistant_state.wechat_connected)
        return;

    // 检查是否有来自微信的语音消息
    char wechat_message[512];
    if (receive_wechat_message("VOICE:", wechat_message, sizeof(wechat_message)) > 0)
    {
        printf("📱 收到微信语音: %s\n", wechat_message);

        // 处理微信语音指令
        process_voice_command(wechat_message);
    }

    // 检查是否有TTS请求
    char tts_request[512];
    if (receive_wechat_message("TTS:", tts_request, sizeof(tts_request)) > 0)
    {
        printf("📱 收到TTS请求: %s\n", tts_request);
        speak_message(tts_request);
    }
}

/**
 * @brief 发送语音交互到微信
 * @param question 问题
 * @param answer 回答
 */
void send_voice_interaction_to_wechat(const char *question, const char *answer)
{
    char json_data[1024];

    snprintf(json_data, sizeof(json_data),
             "{"
             "\"type\":\"voice_interaction\","
             "\"question\":\"%s\","
             "\"answer\":\"%s\","
             "\"timestamp\":\"%s\","
             "\"confidence\":%.2f,"
             "\"session_id\":%u"
             "}",
             question, answer, get_current_time_string(),
             g_last_recognition.confidence,
             g_conversation_context.session_start_time);

    send_data_to_wechat(json_data);
}

/**
 * @brief 检查超时和错误恢复
 * @param current_time 当前时间
 */
void check_timeout_and_recovery(uint32_t current_time)
{
    // 检查处理超时
    if (g_assistant_state.is_processing &&
        current_time - g_audio_buffer.recording_start_time > 10000)
    {
        printf("⚠️ 语音处理超时，重置状态\n");
        g_assistant_state.is_processing = false;
        g_audio_buffer.is_recording = false;
    }

    // 检查错误恢复
    if (g_assistant_state.error_count >= 5)
    {
        printf("🔄 错误次数过多，重启语音系统\n");
        restart_voice_system();
    }

    // 检查长时间无交互
    if (current_time - g_assistant_state.last_interaction_time > 1800000)
    { // 30分钟
        speak_message("我还在这里为您服务，有什么需要帮助的吗？");
        g_assistant_state.last_interaction_time = current_time;
    }
}

/**
 * @brief 定期保存对话上下文
 * @param current_time 当前时间
 */
void save_conversation_context_periodically(uint32_t current_time)
{
    static uint32_t last_save_time = 0;

    if (current_time - last_save_time >= 300000)
    { // 每5分钟保存一次
        save_conversation_context(&g_conversation_context);
        last_save_time = current_time;
    }
}

/**
 * @brief 播放欢迎消息
 */
void speak_welcome_message(void)
{
    const char *welcome_messages[] = {
        "智能学习桌小助手为您服务，有什么可以帮助您的吗？",
        "您好，我是您的学习助手，随时为您提供帮助。",
        "欢迎回来，让我们一起开始高效的学习时光！"};

    int index = rand() % 3;
    speak_message(welcome_messages[index]);
}

/**
 * @brief 重启语音系统
 */
void restart_voice_system(void)
{
    printf("🔄 重启语音系统...\n");

    // 清理当前状态
    voice_interaction_cleanup();

    // 重新初始化
    delay_ms(1000);
    voice_interaction_init();

    g_assistant_state.error_count = 0;
}

/**
 * @brief 语音系统自检
 * @return int 自检结果
 */
int voice_system_self_test(void)
{
    printf("🔍 语音系统自检...\n");

    // 音频硬件测试
    if (test_audio_hardware() != 0)
    {
        printf("❌ 音频硬件测试失败\n");
        return -1;
    }

    // 网络连接测试
    if (test_network_connectivity() != 0)
    {
        printf("❌ 网络连接测试失败\n");
        return -1;
    }

    // API连接测试
    if (test_ai_api_connectivity() != 0)
    {
        printf("⚠️ AI API连接测试失败，将使用降级模式\n");
        g_assistant_state.ai_enabled = false;
    }

    printf("✅ 语音系统自检完成\n");
    return 0;
}

/**
 * @brief 清理语音交互系统
 */
void voice_interaction_cleanup(void)
{
    printf("🧹 清理语音交互系统...\n");

    // 保存最终对话上下文
    save_conversation_context(&g_conversation_context);

    // 发送会话总结到微信
    send_conversation_summary_to_wechat();

    // 清理硬件资源
    audio_hardware_cleanup();

    // 清理网络连接
    wifi_communication_cleanup();

    printf("✅ 语音交互系统清理完成\n");
}

/**
 * @brief 发送对话总结到微信
 */
void send_conversation_summary_to_wechat(void)
{
    char summary[512];

    snprintf(summary, sizeof(summary),
             "{"
             "\"type\":\"conversation_summary\","
             "\"total_interactions\":%d,"
             "\"session_duration\":%u,"
             "\"ai_enabled\":%s,"
             "\"error_count\":%d,"
             "\"last_interaction\":\"%s\""
             "}",
             g_conversation_context.total_interactions,
             get_system_time_ms() - g_conversation_context.session_start_time,
             g_assistant_state.ai_enabled ? "true" : "false",
             g_assistant_state.error_count,
             get_current_time_string());

    send_data_to_wechat(summary);
}

// ========== 辅助工具函数 ==========

/**
 * @brief 读取音频样本
 * @param pin 引脚
 * @return int16_t 音频样本
 */
int16_t read_audio_sample(int pin)
{
    // 从ADC读取音频数据
    int raw_value = analogRead(pin);
    return (int16_t)(raw_value - 2048); // 转换为有符号16位值
}

/**
 * @brief 播放蜂鸣声
 * @param frequency 频率
 * @param duration 持续时间
 */
void play_beep(int frequency, int duration)
{
    // 实现蜂鸣器播放逻辑
    tone(BUZZER_PIN, frequency, duration);
    delay(duration);
    noTone(BUZZER_PIN);
}

/**
 * @brief 获取当前时间字符串
 * @return const char* 时间字符串
 */
const char *get_current_time_string(void)
{
    static char time_str[20];
    time_t now = time(NULL);
    struct tm *tm_info = localtime(&now);
    strftime(time_str, sizeof(time_str), "%H:%M:%S", tm_info);
    return time_str;
}

// ========== 模块结束 ==========